package utils

import (
	"fmt"
	"regexp"
	"strconv"
	"strings"
)

// MatchString
// 检查正则表达式是否与给定的源字符串匹配。
func MatchString(src, pattern string) bool {
	matched, err := regexp.MatchString(pattern, src)
	if err != nil { // 处理正则表达式编译错误
		fmt.Println("Invalid pattern:", err.Error())
		return false
	}
	return matched
}

// RemoveTextWithinParens
// 从字符串中删除括号内的文本。
func RemoveTextWithinParens(str string) string {
	// 编译正则表达式以匹配 ( 和 )。
	re := regexp.MustCompile(`\(.*?\)`)
	// 将匹配的文本替换为空字符串。
	return re.ReplaceAllString(str, "")
}

// RemoveTextWithinMatch
// 按正则表达式移除字符串中的行
// method为1则移除匹配项
// method为2则移除不匹配项
func RemoveTextWithinMatch(str string, pattern string, method int) string {
	if method != 1 && method != 2 {
		return str
	}
	array := strings.Split(str, "\n")
	result := make([]string, 0)
	for _, item := range array {
		match := MatchString(item, pattern)
		// 如果method为1，那么移除匹配项，所以判断未匹配的加入返回切片
		if method == 1 && !match {
			result = append(result, strings.TrimLeft(item, "\r\n "))
		}
		// 如果method为2，那么移除不匹配项，所以判断匹配的加入返回切片
		if method == 2 && match {
			result = append(result, strings.TrimLeft(item, "\r\n "))
		}
	}
	return strings.Join(result, "\n")
}

// RemoveMultiSpaces
// 从字符串中移除多个连续空格字符
func RemoveMultiSpaces(str string) string {
	arr := strings.Split(str, " ")
	result := make([]string, 0)
	for _, s := range arr {
		if s != "" {
			result = append(result, s)
		}
	}
	return strings.Join(result, " ")
}

// StringIsInt
// 检查字符串是否是一个整数。
func StringIsInt(str string) (int, bool) {
	result, err := strconv.Atoi(str)
	return result, err == nil
}

// StringIsInt64
// 检查字符串是否是一个64位整数。
func StringIsInt64(str string) (int64, bool) {
	result, err := strconv.ParseInt(str, 10, 64)
	return result, err == nil
}

// StringIsEmpty
// 检查字符串是否为空。
func StringIsEmpty(str string) bool {
	return str == ""
}

// StringEndWithIgnoreCase
// 检查字符串是否以指定的后缀结尾，忽略大小写。
func StringEndWithIgnoreCase(str, suffix string) bool {
	return strings.HasSuffix(strings.ToLower(str), strings.ToLower(suffix))
}

// StringEndWith
// 检查字符串是否以指定的后缀结尾。
func StringEndWith(str, suffix string) bool {
	return strings.HasSuffix(str, suffix)
}

// StringStartWithIgnoreCase
// 检查字符串是否以指定的前缀开头，忽略大小写。
func StringStartWithIgnoreCase(str, prefix string) bool {
	return strings.HasPrefix(strings.ToLower(str), strings.ToLower(prefix))

}

// StringStartWith
// 检查字符串是否以指定的前缀开头。
func StringStartWith(str, prefix string) bool {
	return strings.HasPrefix(str, prefix)
}

// TrimTrailingCharacter
// 从字符串中删除尾随字符。
func TrimTrailingCharacter(str, character string) string {
	return strings.TrimRight(str, character)
}

// TrimTrailingCharacterIgnoreCase
// 从字符串中删除尾随字符，忽略大小写。
func TrimTrailingCharacterIgnoreCase(str, character string) string {
	return strings.TrimRight(strings.ToLower(str), strings.ToLower(character))
}

// TrimLeadingCharacter
// 从字符串中删除前导字符。
func TrimLeadingCharacter(str, character string) string {
	return strings.TrimLeft(str, character)
}

// TrimLeadingCharacterIgnoreCase
// 从字符串中删除前导字符，忽略大小写。
func TrimLeadingCharacterIgnoreCase(str, character string) string {
	return strings.TrimLeft(strings.ToLower(str), strings.ToLower(character))
}

// RemoveItemsContainingSubstring
// 从字符串数组切片里移除包含substr字符串的项并移除连续空格字符
func RemoveItemsContainingSubstring(arr []string, substr string) []string {
	result := make([]string, 0)
	for _, s := range arr {
		if !strings.Contains(s, substr) && s != "" {
			result = append(result, RemoveMultiSpaces(strings.TrimSpace(s)))
		}
	}
	return result
}

// RemoveItemsNotContainingSubstring
// 从字符串数组切片里移除不包含substr字符串的项并移除连续空格字符
func RemoveItemsNotContainingSubstring(arr []string, substr string) []string {
	result := make([]string, 0)
	for _, s := range arr {
		if strings.Contains(s, substr) {
			result = append(result, RemoveMultiSpaces(strings.TrimSpace(s)))
		}
	}
	return result
}

// RemoveFirstString
// 从字符串数组切片里移除第一个元素
func RemoveFirstString(slice []string) []string {
	if len(slice) == 0 {
		return slice // 或者返回nil，根据你的需求而定
	}
	// 将第二个元素到最后一个元素前移
	copy(slice, slice[1:])
	// 缩短切片长度
	return slice[:len(slice)-1]
}

// RemoveMatchString
// 按正则表达式移除字符串数组切片中的元素
// method为1则移除匹配项
// method为2则移除不匹配项
func RemoveMatchString(slice []string, pattern string, method int) []string {
	// 如果method不为1和2，则返回原切片
	if method != 1 && method != 2 {
		return slice
	}
	result := make([]string, 0)
	for _, item := range slice {
		match := MatchString(item, pattern)
		// 如果method为1，那么移除匹配项，所以判断未匹配的加入返回切片
		if method == 1 && !match {
			result = append(result, item)
		}
		// 如果method为2，那么移除不匹配项，所以判断匹配的加入返回切片
		if method == 2 && match {
			result = append(result, item)
		}
	}
	return result
}
